开发了那么多项目，你能自己手写个健壮的链表出来吗？

阅读本文大概需要5分钟

上次写了篇如果让你手写个栈和队列，你还会写吗？是和一个CSDN上的朋友闲聊时候给我的启发，决定在公众号里连更一下经典数据结构和算法的文章，和大家一起巩固巩固内功。

今天来手写一个链表。虽然是用Java写的，但招式只是形式，内功还是最重要的

我们知道，数组作为数据存储结构有一定的缺陷。在无序数组中，搜索时低效的；而在有序数组中，插入效率又很低；不管在哪一种数组中删除效率都很低。况且一个数组创建后，它的大小是无法改变的。

而链表可能是继数组之后第二种使用得最广泛的通用数据结构了。这里主要来讨论并写一个单链表和双向链表。

顾名思义，单链表只能从表头到表尾的顺序，每个节点中保存了指向下一个节点的指针；双向链表则可以反向遍历，因为节点中既保存了向后节点的指针，又保存了向前节点的指针。由于链表结构相对简单，这里不再赘述，直接通过程序来查看它们常见的操作：

1. 单链表

1. public class LinkedList {

2.    private Link first;

3.    private int nElem; //链表中节点数量

4.    public LinkedList() {

5.        first = null;

6.        nElem = 0;

7.    }

8.    public void insertFirst(int value) {//添加头结点

9.        Link newLink = new Link(value);

10.        newLink.next = first; //newLink-->old first

11.        first = newLink; //first-->newLink

12.        nElem ++;

13.    }

14.    public Link deleteFirst() { //删除头结点

15.        if(isEmpty()) {

16.            System.out.println("链表为空！");

17.            return null;

18.        }

19.        Link temp = first;

20.        first = first.next;

21.        nElem --;

22.        return temp;

23.    }

24.    /************************************************************

25.     ***下面是有序链表的插入***

26.     ***这样简单排序就可以用链表来实现，复杂度为O(N)

27.     ***定义一个方法，传入一个数组，

28.     ***在方法内，遍历数组并调用insert方法就可以将数组中的数据排好序

29.     ***********************************************************/

30.    public void insert(int value) {

31.        Link newLink = new Link(value);

32.        Link previous = null;

33.        Link current = first;

34.        while(current != null && value > current.data) {

35.            previous = current;

36.            current = current.next;

37.        }

38.        if(previous == null) {

39.            first = newLink;        

40.        }

41.        else {

42.            previous.next = newLink;

43.        }

44.        newLink.next = current;

45.        nElem ++;

46.    }

47.    public Link find(int value) { //查找特定的节点

48.        Link current = first;

49.        while(current.data != value) {

50.            if(current.next == null)

51.                return null;

52.            else

53.                current = current.next;

54.        }  

55.        return current;

56.    }

57.    public Link delete(int value) { //删除特定的节点

58.        Link current = first;

59.        Link previous = first;

60.        while(current.data != value) {

61.            if(current.next == null) {

62.                return null;

63.            }

64.            previous = current;

65.            current = current.next;

66.        }

67.        if(current == first) {

68.            first = first.next;

69.        }

70.        else {

71.            previous.next = current.next;

72.        }

73.        nElem --;

74.        return current;

75.    }

76.    public void displayList() {

77.        if(isEmpty()){

78.            System.out.println("链表为空！");

79.            return;

80.        }

81.        Link current = first;

82.        while(current != null) {

83.            current.displayLink();

84.            current = current.next;

85.        }

86.        System.out.println(" ");

87.    }

88.    public boolean isEmpty() {

89.        return (first == null);

90.    }

91.    public int size() {

92.        return nElem;

93.    }

94. }

95. class Link {

96.    public int data;

97.    public Link next;

98.    public Link(int data) {

99.        this.data = data;

100.        this.next = null;

101.    }

102.    public void displayLink() {

103.        System.out.print("{" + data + "} ");

104.    }

105. }

2. 双向链表

1. public class DoublyLinkedList {

2.    private Node first; //头节点

3.    private Node last; //尾节点

4.    private int size;

5.    public DoublyLinkedList() {

6.        first = null;

7.        last = null;

8.        size = 0;

9.    }

10.    public int size() {

11.        return size;

12.    }

13.    public boolean isEmpty() {

14.        return (first == null);

15.    }

16.    public void insertFirst(long value) { //插入头节点

17.        Node newLink = new Node(value);

18.        if(isEmpty()) {

19.            last = newLink;

20.        }

21.        else{

22.            first.previous = newLink; //newLink <-- oldFirst.previous

23.            newLink.next = first; //newLink.next --> first

24.        }

25.        first = newLink; //first --> newLink

26.        size ++;

27.    }

28.    public void insertLast(long value) {//插入尾节点

29.        Node newLink = new Node(value);

30.        if(isEmpty()){

31.            first = newLink;

32.        }

33.        else {

34.            last.next = newLink; //newLink <-- oldLast.next

35.            newLink.previous = last; //newLink.previous --> last

36.        }

37.        last = newLink;

38.        size ++;

39.    }

40.    public Node deleteFirst() {//删除头结点

41.        if(first == null) {

42.            System.out.println("链表为空！");

43.            return null;

44.        }

45.        Node temp = first;

46.        if(first.next == null) { //只有一个节点

47.            last = null;

48.        }

49.        else {

50.            first.next.previous = null;

51.        }

52.        first = first.next;

53.        size --;

54.        return temp;

55.    }

56.    public Node deleteLast() {//删除尾节点

57.        if(last == null) {

58.            System.out.println("链表为空");

59.            return null;

60.        }

61.        Node temp = last;

62.        if(last.previous == null) { //只有一个节点

63.            first = null;

64.        }

65.        else {

66.            last.previous.next = null;

67.        }

68.        last = last.previous;

69.        size --;

70.        return temp;

71.    }

72.    public boolean insertAfter(long key, long value) { //在key后面插入值为value的新节点

73.        Node current = first;

74.        while(current.data != key) {

75.            current = current.next;

76.            if(current == null) {

77.                System.out.println("不存在值为" + value + "的节点！");

78.                return false;

79.            }

80.        }

81.        if(current == last) {

82.            insertLast(value);

83.        }

84.        else {

85.            Node newLink = new Node(value);

86.            newLink.next = current.next;

87.            current.next.previous = newLink;

88.            newLink.previous = current;

89.            current.next = newLink;

90.            size ++;

91.        }

92.        return true;

93.    }

94.    public Node deleteNode(long key) {//删除指定位置的节点

95.        Node current = first;

96.        while(current.data != key) {

97.            current = current.next;

98.            if(current == null) {

99.                System.out.println("不存在该节点！");

100.                return null;

101.            }

102.        }

103.        if(current == first) {

104.            deleteFirst();

105.        }

106.        else if(current == last){

107.            deleteLast();

108.        }

109.        else {

110.            current.previous.next = current.next;

111.            current.next.previous = current.previous;

112.            size --;

113.        }

114.        return current;

115.    }

116.    public void displayForward() { //从头到尾遍历链表

117.        System.out.println("List(first --> last): ");

118.        Node current = first;

119.        while(current != null) {

120.            current.displayLink();

121.            current = current.next;

122.        }

123.        System.out.println(" ");

124.    }

125.    public void displayBackward() { //从尾到头遍历链表

126.        System.out.println("List(last --> first): ");

127.        Node current = last;

128.        while(current != null) {

129.            current.displayLink();

130.            current = current.previous;

131.        }

132.        System.out.println(" ");

133.    }

134. }

135. class Node {

136.    public long data;

137.    public Node next;

138.    public Node previous;

139.    public Node(long value) {

140.        data = value;

141.        next = null;

142.        previous = null;

143.    }

144.    public void displayLink() {

145.        System.out.print(data + " ");

146.    }

147. }

在表头插入和删除速度很快，仅需改变一两个引用值，所以花费 O(1) 的时间。平均起来，查找、删除和在指定节点后面插入都需要搜索链表中的一半节点，需要O(N)次比较。在数组中执行这些操作也需要 O(N) 次比较，但是链表仍然要比数组快一些，因为当插入和删除节点时，链表不需要移动任何东西，增加的效率是很显著的，特别是当复制时间远远大于比较时间的时候。

当然，链表比数组优越的另一个重要方面是链表需要多少内存就可以用多少内存，并且可以扩展到所有可用内存。数组的大小在它创建的时候就固定了，所以经常由于数组太大导致效率低下，或者数组太小导致空间溢出。可变数组可以解决这个问题，但是它经常只允许以固定大小的增量扩展，这个解决方案在内存使用率上来说还是比链表要低。

END

人之所以能，是相信能！这世上没有天才，你若对得起时间，时间便对得起你。关注我们，每天进步一点点~ 

更多推荐阅读：